#include <gmlib/number/uint256.h>

#include <stdexcept>

using namespace number;

void test_uint256_equal()
{
    uint256_t a, b;

    std::uint8_t a0_data[32] = {0x09,0x99,0x50,0xd8,0x36,0xf6,0x75,0xcc,0x81,0xe7,0x4e,0xf5,0xe8,0xe2,0x5d,0x94,0x0e,0xd9,0x04,0x75,0x95,0x31,0x98,0x5d,0x5d,0x9d,0xc9,0xf8,0x18,0x18,0xe8,0x11};
    std::uint8_t b0_data[32] = {0x09,0x99,0x50,0xd8,0x36,0xf6,0x75,0xcc,0x81,0xe7,0x4e,0xf5,0xe8,0xe2,0x5d,0x94,0x0e,0xd9,0x04,0x75,0x95,0x31,0x98,0x5d,0x5d,0x9d,0xc9,0xf8,0x18,0x18,0xe8,0x11};
    bool         cmp0        = true;
    uint256_from_bytes(a, a0_data);
    uint256_from_bytes(b, b0_data);
    if (uint256_equal(a, b) != cmp0)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a1_data[32] = {0x4a,0x23,0xd5,0x96,0x22,0x17,0xbe,0xad,0xdb,0xc4,0x96,0xcb,0x8e,0x81,0x97,0x3e,0x0b,0xec,0xd7,0xb0,0x38,0x98,0xd1,0x90,0xf9,0xeb,0xda,0xcc,0x0c,0xb1,0xe2,0x9c};
    std::uint8_t b1_data[32] = {0xae,0x97,0xba,0x94,0xd0,0xed,0xa8,0x2f,0x8f,0x6d,0x05,0x58,0x4e,0xf8,0xaa,0x38,0x92,0x27,0x66,0x58,0x1e,0x27,0xa1,0xc0,0x8a,0x6a,0x63,0xec,0x24,0xed,0xe6,0xa4};
    bool         cmp1        = false;
    uint256_from_bytes(a, a1_data);
    uint256_from_bytes(b, b1_data);
    if (uint256_equal(a, b) != cmp1)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a2_data[32] = {0xb6,0x4c,0xe4,0x22,0x8c,0x38,0xfb,0x29,0x18,0xf1,0x35,0xd2,0x5f,0x55,0x72,0x03,0x30,0x18,0x50,0xc5,0xa3,0x8f,0xd5,0x47,0x92,0x3a,0x73,0x69,0x94,0xe3,0xbf,0x91};
    std::uint8_t b2_data[32] = {0xb6,0x4c,0xe4,0x22,0x8c,0x38,0xfb,0x29,0x18,0xf1,0x35,0xd2,0x5f,0x55,0x72,0x03,0x30,0x18,0x50,0xc5,0xa3,0x8f,0xd5,0x47,0x92,0x3a,0x73,0x69,0x94,0xe3,0xbf,0x91};
    bool         cmp2        = true;
    uint256_from_bytes(a, a2_data);
    uint256_from_bytes(b, b2_data);
    if (uint256_equal(a, b) != cmp2)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a3_data[32] = {0x83,0x0e,0x07,0xbc,0x1e,0x39,0x8f,0x10,0x12,0xbd,0x4a,0xce,0xfa,0xec,0xbd,0x38,0x9b,0xe4,0xbc,0xfc,0x49,0xb6,0x4a,0x08,0x72,0xe6,0xcc,0x3a,0xba,0xbc,0xed,0x20};
    std::uint8_t b3_data[32] = {0x83,0x0e,0x07,0xbc,0x1e,0x39,0x8f,0x10,0x12,0xbd,0x4a,0xce,0xfa,0xec,0xbd,0x38,0x9b,0xe4,0xbc,0xfc,0x49,0xb6,0x4a,0x08,0x72,0xe6,0xcc,0x3a,0xba,0xbc,0xed,0x20};
    bool         cmp3        = true;
    uint256_from_bytes(a, a3_data);
    uint256_from_bytes(b, b3_data);
    if (uint256_equal(a, b) != cmp3)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a4_data[32] = {0x72,0x15,0x83,0x70,0xd2,0x69,0xa9,0xa5,0xae,0x65,0x8f,0x33,0xfe,0x3b,0x89,0x0b,0x93,0xf4,0x48,0xb3,0xa5,0xaa,0x3c,0x81,0x4f,0x42,0x6d,0xcb,0xb3,0x94,0xfb,0x36};
    std::uint8_t b4_data[32] = {0x76,0x31,0xa9,0x92,0xf0,0xce,0x58,0x35,0x05,0xc6,0xaf,0x07,0x58,0xd5,0x56,0x3d,0xab,0x2c,0xd3,0x1e,0xe3,0x15,0x12,0x88,0x62,0xc3,0x3a,0x4f,0xb7,0x74,0xeb,0x52};
    bool         cmp4        = false;
    uint256_from_bytes(a, a4_data);
    uint256_from_bytes(b, b4_data);
    if (uint256_equal(a, b) != cmp4)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a5_data[32] = {0x2a,0x96,0xfb,0x1a,0x14,0xa0,0xf9,0xe7,0x7f,0x1b,0x10,0x3c,0xdf,0x15,0x82,0xb0,0xea,0xb4,0x77,0xd2,0x64,0x15,0x47,0x9c,0x65,0xdc,0x9f,0x50,0x3f,0x63,0xaf,0x83};
    std::uint8_t b5_data[32] = {0x2a,0x96,0xfb,0x1a,0x14,0xa0,0xf9,0xe7,0x7f,0x1b,0x10,0x3c,0xdf,0x15,0x82,0xb0,0xea,0xb4,0x77,0xd2,0x64,0x15,0x47,0x9c,0x65,0xdc,0x9f,0x50,0x3f,0x63,0xaf,0x83};
    bool         cmp5        = true;
    uint256_from_bytes(a, a5_data);
    uint256_from_bytes(b, b5_data);
    if (uint256_equal(a, b) != cmp5)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a6_data[32] = {0x65,0xe7,0xe4,0x23,0x64,0x72,0xf1,0xa3,0x8f,0x2c,0x6e,0xc8,0xcc,0x41,0x69,0xa3,0xae,0x3a,0x2b,0x7f,0xdf,0xe0,0x18,0x93,0xf3,0xae,0xd0,0xb6,0xc7,0xac,0x14,0x91};
    std::uint8_t b6_data[32] = {0x1a,0x35,0x8c,0xa0,0x0d,0x75,0x98,0x5d,0x99,0xc9,0x43,0x09,0x57,0x0d,0xc1,0x95,0x1c,0x24,0x42,0xf9,0x29,0x8c,0xb3,0xa5,0x70,0xcc,0xec,0x31,0x35,0x71,0x81,0x0a};
    bool         cmp6        = false;
    uint256_from_bytes(a, a6_data);
    uint256_from_bytes(b, b6_data);
    if (uint256_equal(a, b) != cmp6)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a7_data[32] = {0xdf,0xd4,0x3f,0x37,0x12,0x00,0x33,0x9d,0x06,0x87,0x39,0xfa,0x9d,0x1d,0xe2,0xa0,0x5d,0x15,0x8a,0x2f,0xf2,0xee,0x4e,0x45,0x19,0xf9,0x91,0x9c,0x89,0x5f,0xd7,0xb3};
    std::uint8_t b7_data[32] = {0xdf,0xd4,0x3f,0x37,0x12,0x00,0x33,0x9d,0x06,0x87,0x39,0xfa,0x9d,0x1d,0xe2,0xa0,0x5d,0x15,0x8a,0x2f,0xf2,0xee,0x4e,0x45,0x19,0xf9,0x91,0x9c,0x89,0x5f,0xd7,0xb3};
    bool         cmp7        = true;
    uint256_from_bytes(a, a7_data);
    uint256_from_bytes(b, b7_data);
    if (uint256_equal(a, b) != cmp7)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a8_data[32] = {0x7a,0xfb,0x2c,0x68,0x77,0x4b,0x15,0xd7,0xfa,0x52,0x9b,0xa3,0xfe,0x3b,0xfa,0xda,0x7c,0xf2,0x07,0x24,0xd9,0x53,0xee,0x26,0x1d,0x87,0xce,0xc3,0x1f,0x72,0x96,0xab};
    std::uint8_t b8_data[32] = {0x43,0xc7,0x1b,0x9a,0xbd,0x87,0xa8,0x65,0x57,0xb6,0xfb,0x7e,0xbf,0xea,0xa1,0x55,0x1a,0x28,0xf7,0xb3,0x24,0xe4,0xe2,0x5a,0x15,0xfc,0x89,0x9e,0x4f,0xd5,0x8d,0xbe};
    bool         cmp8        = false;
    uint256_from_bytes(a, a8_data);
    uint256_from_bytes(b, b8_data);
    if (uint256_equal(a, b) != cmp8)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a9_data[32] = {0x2a,0xc3,0x44,0x46,0xe8,0x83,0xa1,0xd4,0x5d,0xe0,0x09,0x97,0x84,0xb5,0xa8,0x18,0x42,0xd8,0x72,0x08,0xd8,0x6f,0x40,0xf6,0xb2,0x39,0xf3,0xc7,0x17,0x4c,0x77,0xa2};
    std::uint8_t b9_data[32] = {0xa2,0xed,0xdb,0xbd,0x54,0x64,0xec,0xc2,0x80,0xb0,0xc0,0x8b,0xc7,0x70,0x24,0x20,0x8a,0xa4,0x24,0x8c,0x88,0x57,0xf9,0xa4,0x39,0x08,0xf2,0x27,0xc5,0x9d,0xb9,0x16};
    bool         cmp9        = false;
    uint256_from_bytes(a, a9_data);
    uint256_from_bytes(b, b9_data);
    if (uint256_equal(a, b) != cmp9)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a10_data[32] = {0x47,0x87,0xf9,0x3b,0xca,0x44,0xeb,0x86,0x07,0x26,0xe2,0x5c,0xfd,0x56,0xa9,0x26,0x07,0x6b,0x3e,0x36,0xbb,0x23,0x13,0xf5,0x5b,0x06,0x25,0x8e,0x7e,0x26,0xf3,0x6a};
    std::uint8_t b10_data[32] = {0x38,0x70,0x38,0x00,0x14,0x9e,0x25,0x9b,0x5d,0x58,0xc7,0x05,0xf9,0x79,0xd0,0x4a,0xf4,0x7a,0xeb,0xdd,0x59,0x7a,0x1e,0xcf,0xfc,0xf0,0x0f,0xec,0xb9,0x1e,0xe9,0xe5};
    bool         cmp10        = false;
    uint256_from_bytes(a, a10_data);
    uint256_from_bytes(b, b10_data);
    if (uint256_equal(a, b) != cmp10)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a11_data[32] = {0xa4,0xa4,0x5e,0xff,0xcc,0xb5,0x73,0xd9,0x58,0x10,0xd6,0x0e,0xa7,0x29,0x91,0xb9,0xe8,0xc1,0x47,0x43,0x7a,0xbe,0xc5,0x39,0x00,0x7d,0x10,0x34,0xd7,0x26,0xc8,0x6b};
    std::uint8_t b11_data[32] = {0xa4,0xa4,0x5e,0xff,0xcc,0xb5,0x73,0xd9,0x58,0x10,0xd6,0x0e,0xa7,0x29,0x91,0xb9,0xe8,0xc1,0x47,0x43,0x7a,0xbe,0xc5,0x39,0x00,0x7d,0x10,0x34,0xd7,0x26,0xc8,0x6b};
    bool         cmp11        = true;
    uint256_from_bytes(a, a11_data);
    uint256_from_bytes(b, b11_data);
    if (uint256_equal(a, b) != cmp11)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a12_data[32] = {0xe7,0xa4,0x63,0x09,0x97,0x3f,0x79,0x86,0x26,0xb1,0xcf,0xfc,0x07,0x0d,0x71,0x09,0x20,0x85,0x96,0x34,0xfe,0x3c,0x9c,0x8f,0x2b,0x85,0x5c,0x1f,0x28,0xaa,0xca,0x51};
    std::uint8_t b12_data[32] = {0x23,0xa5,0xef,0x88,0xef,0x02,0x09,0x0b,0xbf,0xde,0xfc,0x15,0x86,0xce,0x03,0xf9,0x1a,0x4f,0x44,0xf9,0xa6,0x51,0x14,0x45,0xb9,0xf3,0x63,0x5c,0xf8,0x8c,0x42,0x2b};
    bool         cmp12        = false;
    uint256_from_bytes(a, a12_data);
    uint256_from_bytes(b, b12_data);
    if (uint256_equal(a, b) != cmp12)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a13_data[32] = {0x80,0x4c,0x25,0xd6,0x4a,0xff,0xdc,0xd1,0x36,0x78,0xbc,0x8d,0x40,0x78,0x3f,0x0a,0x07,0x2a,0x98,0xd2,0x36,0x06,0xde,0xfc,0xdf,0xb8,0x5c,0x0d,0xd3,0x7e,0xe9,0x15};
    std::uint8_t b13_data[32] = {0x80,0x4c,0x25,0xd6,0x4a,0xff,0xdc,0xd1,0x36,0x78,0xbc,0x8d,0x40,0x78,0x3f,0x0a,0x07,0x2a,0x98,0xd2,0x36,0x06,0xde,0xfc,0xdf,0xb8,0x5c,0x0d,0xd3,0x7e,0xe9,0x15};
    bool         cmp13        = true;
    uint256_from_bytes(a, a13_data);
    uint256_from_bytes(b, b13_data);
    if (uint256_equal(a, b) != cmp13)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a14_data[32] = {0x82,0xb3,0x35,0x99,0x86,0x04,0x87,0x19,0x26,0xde,0xbf,0xdb,0x88,0x25,0xae,0x56,0x21,0x79,0xb3,0x7d,0x80,0x6c,0x10,0xb5,0xe0,0xcf,0xab,0x4c,0xea,0xef,0xc4,0xd2};
    std::uint8_t b14_data[32] = {0xcc,0x96,0x6f,0x46,0xc6,0xaa,0x7d,0x55,0x01,0x01,0xb8,0x11,0x9b,0xca,0x3c,0xb7,0x2e,0xe0,0x28,0x9d,0xc6,0xc9,0x1b,0x92,0x70,0xac,0x06,0xac,0xdf,0x70,0x30,0x17};
    bool         cmp14        = false;
    uint256_from_bytes(a, a14_data);
    uint256_from_bytes(b, b14_data);
    if (uint256_equal(a, b) != cmp14)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a15_data[32] = {0x81,0xf9,0x8b,0x52,0x19,0x05,0xd5,0x91,0xc5,0xb2,0xe7,0x5a,0x0a,0xcd,0x8b,0xe1,0x46,0xe4,0x09,0x90,0x30,0xf9,0x70,0x58,0x3f,0x9d,0x52,0xf9,0x0e,0x8b,0xec,0x94};
    std::uint8_t b15_data[32] = {0x81,0xf9,0x8b,0x52,0x19,0x05,0xd5,0x91,0xc5,0xb2,0xe7,0x5a,0x0a,0xcd,0x8b,0xe1,0x46,0xe4,0x09,0x90,0x30,0xf9,0x70,0x58,0x3f,0x9d,0x52,0xf9,0x0e,0x8b,0xec,0x94};
    bool         cmp15        = true;
    uint256_from_bytes(a, a15_data);
    uint256_from_bytes(b, b15_data);
    if (uint256_equal(a, b) != cmp15)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a16_data[32] = {0xab,0xd0,0xd7,0xfb,0x12,0x92,0x61,0x85,0x50,0xe4,0x0d,0x54,0x71,0x2e,0xa6,0xb3,0x64,0x71,0xfd,0xe4,0x1f,0x22,0x9d,0xd0,0x6a,0xa8,0xb9,0xe0,0x23,0x1b,0x3e,0x14};
    std::uint8_t b16_data[32] = {0xab,0xd0,0xd7,0xfb,0x12,0x92,0x61,0x85,0x50,0xe4,0x0d,0x54,0x71,0x2e,0xa6,0xb3,0x64,0x71,0xfd,0xe4,0x1f,0x22,0x9d,0xd0,0x6a,0xa8,0xb9,0xe0,0x23,0x1b,0x3e,0x14};
    bool         cmp16        = true;
    uint256_from_bytes(a, a16_data);
    uint256_from_bytes(b, b16_data);
    if (uint256_equal(a, b) != cmp16)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a17_data[32] = {0x5d,0xaf,0x10,0x6d,0xb8,0xde,0xe0,0x81,0x17,0x9a,0x07,0x1e,0x51,0x8a,0xe4,0x52,0x5b,0x4b,0x1b,0x75,0x32,0x1c,0x52,0x96,0x6b,0xd8,0xc6,0x76,0x56,0xd0,0x50,0xcd};
    std::uint8_t b17_data[32] = {0x5d,0xaf,0x10,0x6d,0xb8,0xde,0xe0,0x81,0x17,0x9a,0x07,0x1e,0x51,0x8a,0xe4,0x52,0x5b,0x4b,0x1b,0x75,0x32,0x1c,0x52,0x96,0x6b,0xd8,0xc6,0x76,0x56,0xd0,0x50,0xcd};
    bool         cmp17        = true;
    uint256_from_bytes(a, a17_data);
    uint256_from_bytes(b, b17_data);
    if (uint256_equal(a, b) != cmp17)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a18_data[32] = {0x1f,0x26,0x42,0xaa,0xdc,0xde,0xd2,0x04,0x43,0xb3,0x0f,0x66,0x11,0x0e,0x2c,0xb6,0x38,0xef,0xba,0xeb,0xdb,0x31,0xcc,0xd2,0x9b,0xb1,0x83,0xe1,0x15,0x70,0x26,0x6b};
    std::uint8_t b18_data[32] = {0x1f,0x26,0x42,0xaa,0xdc,0xde,0xd2,0x04,0x43,0xb3,0x0f,0x66,0x11,0x0e,0x2c,0xb6,0x38,0xef,0xba,0xeb,0xdb,0x31,0xcc,0xd2,0x9b,0xb1,0x83,0xe1,0x15,0x70,0x26,0x6b};
    bool         cmp18        = true;
    uint256_from_bytes(a, a18_data);
    uint256_from_bytes(b, b18_data);
    if (uint256_equal(a, b) != cmp18)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a19_data[32] = {0xe3,0x83,0x8b,0x9e,0xd5,0xa9,0x42,0x2a,0x8b,0xc0,0x83,0x11,0x7e,0xb8,0x6c,0x57,0xa8,0x11,0x00,0xa1,0x6e,0xa3,0x30,0xa1,0xa6,0x6d,0x58,0xb5,0xd1,0xa4,0xc0,0x1e};
    std::uint8_t b19_data[32] = {0x57,0xbb,0x7d,0x97,0x3a,0xc4,0xda,0x9a,0xfb,0x81,0x39,0x21,0x37,0x16,0x1c,0x16,0xb0,0x0f,0xd7,0xbb,0x4e,0xca,0xde,0xa2,0x81,0xb6,0x2b,0xb5,0xf8,0x66,0x64,0xae};
    bool         cmp19        = false;
    uint256_from_bytes(a, a19_data);
    uint256_from_bytes(b, b19_data);
    if (uint256_equal(a, b) != cmp19)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a20_data[32] = {0x03,0xa6,0x39,0x66,0x21,0x3b,0xca,0x7f,0xd6,0x44,0xde,0x2f,0x0d,0xec,0x68,0x23,0xfb,0x5c,0x9d,0x56,0x58,0xf9,0x2d,0xea,0xfd,0x4b,0xd0,0x30,0x67,0x9a,0x44,0xdd};
    std::uint8_t b20_data[32] = {0x03,0xa6,0x39,0x66,0x21,0x3b,0xca,0x7f,0xd6,0x44,0xde,0x2f,0x0d,0xec,0x68,0x23,0xfb,0x5c,0x9d,0x56,0x58,0xf9,0x2d,0xea,0xfd,0x4b,0xd0,0x30,0x67,0x9a,0x44,0xdd};
    bool         cmp20        = true;
    uint256_from_bytes(a, a20_data);
    uint256_from_bytes(b, b20_data);
    if (uint256_equal(a, b) != cmp20)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a21_data[32] = {0x43,0x63,0xe5,0xd9,0x00,0xed,0x6b,0x02,0x72,0x21,0x8f,0xdc,0x44,0xdf,0x96,0xff,0x28,0x54,0x14,0x24,0x2f,0x73,0x3b,0x05,0x75,0x9e,0xb5,0x59,0x0b,0x94,0xaf,0x3a};
    std::uint8_t b21_data[32] = {0x43,0x63,0xe5,0xd9,0x00,0xed,0x6b,0x02,0x72,0x21,0x8f,0xdc,0x44,0xdf,0x96,0xff,0x28,0x54,0x14,0x24,0x2f,0x73,0x3b,0x05,0x75,0x9e,0xb5,0x59,0x0b,0x94,0xaf,0x3a};
    bool         cmp21        = true;
    uint256_from_bytes(a, a21_data);
    uint256_from_bytes(b, b21_data);
    if (uint256_equal(a, b) != cmp21)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a22_data[32] = {0x01,0x44,0x70,0x2b,0xc6,0xb7,0x89,0xef,0x81,0x36,0x5a,0xcc,0x3f,0x88,0xaf,0x59,0x33,0x73,0x6d,0xcc,0xa7,0xf0,0xc9,0x9e,0x80,0xb5,0x24,0x4a,0x47,0x67,0xe1,0xfa};
    std::uint8_t b22_data[32] = {0x01,0x44,0x70,0x2b,0xc6,0xb7,0x89,0xef,0x81,0x36,0x5a,0xcc,0x3f,0x88,0xaf,0x59,0x33,0x73,0x6d,0xcc,0xa7,0xf0,0xc9,0x9e,0x80,0xb5,0x24,0x4a,0x47,0x67,0xe1,0xfa};
    bool         cmp22        = true;
    uint256_from_bytes(a, a22_data);
    uint256_from_bytes(b, b22_data);
    if (uint256_equal(a, b) != cmp22)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a23_data[32] = {0xa0,0x98,0xd6,0x91,0x83,0x52,0xbc,0x85,0xe4,0x56,0x55,0x9c,0xb7,0x0a,0xf5,0xf2,0xd5,0xd5,0x89,0x1f,0xd3,0x29,0xd6,0x5c,0x0b,0x35,0xb1,0xde,0x25,0x0e,0x7b,0x34};
    std::uint8_t b23_data[32] = {0x15,0xc8,0x91,0xff,0x3a,0xdd,0x65,0x27,0xa4,0x94,0x6d,0x15,0xb1,0x7d,0xd2,0x55,0xf4,0xc1,0x82,0x26,0xae,0xd2,0x3b,0x0f,0xb6,0x10,0x4b,0x84,0xe4,0x90,0x7d,0x49};
    bool         cmp23        = false;
    uint256_from_bytes(a, a23_data);
    uint256_from_bytes(b, b23_data);
    if (uint256_equal(a, b) != cmp23)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a24_data[32] = {0x7d,0x42,0x64,0x6f,0x3e,0x9b,0x76,0x8f,0xae,0x40,0x01,0xe3,0x88,0x0c,0xb4,0x01,0xa0,0x50,0x60,0x98,0x04,0xd2,0xbe,0x09,0xa0,0xb5,0x58,0x64,0x0c,0xff,0xf0,0x54};
    std::uint8_t b24_data[32] = {0x32,0xc3,0x24,0x44,0xa4,0x8c,0x1d,0x5c,0xa1,0xfe,0xb6,0x24,0x9d,0xf2,0x02,0x5f,0x0b,0xf7,0xa4,0xbd,0xc4,0x58,0x27,0x2f,0x49,0x8d,0xbf,0xa8,0xaf,0x06,0xbc,0xf7};
    bool         cmp24        = false;
    uint256_from_bytes(a, a24_data);
    uint256_from_bytes(b, b24_data);
    if (uint256_equal(a, b) != cmp24)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a25_data[32] = {0x91,0x58,0xd4,0xa8,0x9f,0x03,0xbc,0x5a,0x4d,0xee,0x48,0x12,0xb1,0x61,0x07,0xf1,0xbe,0x43,0x7c,0x7b,0xa6,0xca,0xf4,0xa3,0x41,0x02,0x3a,0xed,0x54,0xef,0x12,0x5a};
    std::uint8_t b25_data[32] = {0x91,0x58,0xd4,0xa8,0x9f,0x03,0xbc,0x5a,0x4d,0xee,0x48,0x12,0xb1,0x61,0x07,0xf1,0xbe,0x43,0x7c,0x7b,0xa6,0xca,0xf4,0xa3,0x41,0x02,0x3a,0xed,0x54,0xef,0x12,0x5a};
    bool         cmp25        = true;
    uint256_from_bytes(a, a25_data);
    uint256_from_bytes(b, b25_data);
    if (uint256_equal(a, b) != cmp25)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a26_data[32] = {0xfa,0x66,0x72,0xcd,0x4f,0xc9,0xe9,0x18,0x33,0x02,0x0c,0xcd,0x8c,0x90,0x47,0x3e,0xe4,0xc7,0x17,0xfd,0xfe,0x48,0xef,0x63,0x1e,0x56,0x34,0x08,0xc4,0x65,0x3c,0xde};
    std::uint8_t b26_data[32] = {0xfa,0x66,0x72,0xcd,0x4f,0xc9,0xe9,0x18,0x33,0x02,0x0c,0xcd,0x8c,0x90,0x47,0x3e,0xe4,0xc7,0x17,0xfd,0xfe,0x48,0xef,0x63,0x1e,0x56,0x34,0x08,0xc4,0x65,0x3c,0xde};
    bool         cmp26        = true;
    uint256_from_bytes(a, a26_data);
    uint256_from_bytes(b, b26_data);
    if (uint256_equal(a, b) != cmp26)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a27_data[32] = {0x28,0xb8,0x80,0x73,0x06,0x5b,0x8c,0x35,0x64,0xe2,0x76,0x02,0x7c,0x73,0xb6,0xc9,0xe0,0x4b,0x0d,0xce,0xe5,0xd0,0x0a,0x4d,0x7f,0x75,0x95,0xb5,0x3b,0x3b,0xf4,0xbf};
    std::uint8_t b27_data[32] = {0x28,0xb8,0x80,0x73,0x06,0x5b,0x8c,0x35,0x64,0xe2,0x76,0x02,0x7c,0x73,0xb6,0xc9,0xe0,0x4b,0x0d,0xce,0xe5,0xd0,0x0a,0x4d,0x7f,0x75,0x95,0xb5,0x3b,0x3b,0xf4,0xbf};
    bool         cmp27        = true;
    uint256_from_bytes(a, a27_data);
    uint256_from_bytes(b, b27_data);
    if (uint256_equal(a, b) != cmp27)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a28_data[32] = {0xc0,0x30,0x1b,0x21,0x53,0x15,0x8c,0xe4,0x00,0x72,0x1f,0x84,0x54,0xd1,0xac,0x6b,0xd7,0x19,0x61,0x89,0x1e,0xf3,0xea,0x44,0x50,0xea,0x7d,0xa7,0x60,0x48,0x7e,0x15};
    std::uint8_t b28_data[32] = {0xc0,0x30,0x1b,0x21,0x53,0x15,0x8c,0xe4,0x00,0x72,0x1f,0x84,0x54,0xd1,0xac,0x6b,0xd7,0x19,0x61,0x89,0x1e,0xf3,0xea,0x44,0x50,0xea,0x7d,0xa7,0x60,0x48,0x7e,0x15};
    bool         cmp28        = true;
    uint256_from_bytes(a, a28_data);
    uint256_from_bytes(b, b28_data);
    if (uint256_equal(a, b) != cmp28)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a29_data[32] = {0x26,0x1f,0x40,0xdf,0xef,0x82,0xd1,0xa3,0xa2,0x8c,0xf7,0xb1,0x49,0x1e,0x99,0xf5,0xa9,0x77,0x66,0xfb,0xd5,0xad,0x53,0x60,0x0d,0x36,0xce,0x2c,0x1a,0x09,0xa8,0x40};
    std::uint8_t b29_data[32] = {0x26,0x1f,0x40,0xdf,0xef,0x82,0xd1,0xa3,0xa2,0x8c,0xf7,0xb1,0x49,0x1e,0x99,0xf5,0xa9,0x77,0x66,0xfb,0xd5,0xad,0x53,0x60,0x0d,0x36,0xce,0x2c,0x1a,0x09,0xa8,0x40};
    bool         cmp29        = true;
    uint256_from_bytes(a, a29_data);
    uint256_from_bytes(b, b29_data);
    if (uint256_equal(a, b) != cmp29)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a30_data[32] = {0x6a,0x34,0xb3,0x71,0x78,0xe1,0x0e,0x70,0x2b,0xb7,0x1c,0x68,0x20,0x97,0x79,0x8c,0x8c,0xd3,0xe4,0x18,0xed,0x41,0x42,0xba,0xe9,0x72,0x9f,0x3f,0x0c,0x89,0xc0,0x01};
    std::uint8_t b30_data[32] = {0x42,0x9a,0x70,0x79,0xa7,0x1f,0x11,0xb2,0xf9,0xee,0x8b,0xc8,0xbd,0x1e,0x69,0x12,0xbd,0x31,0x3b,0xee,0x41,0x78,0x5b,0xc6,0x4c,0x3a,0xc6,0xfc,0x48,0x20,0x82,0x31};
    bool         cmp30        = false;
    uint256_from_bytes(a, a30_data);
    uint256_from_bytes(b, b30_data);
    if (uint256_equal(a, b) != cmp30)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a31_data[32] = {0xa4,0xa9,0x15,0xd0,0x2a,0xd6,0x4c,0xe9,0x1e,0xa7,0x72,0x28,0x64,0xf5,0x49,0x69,0xab,0x3b,0x74,0xfe,0x8e,0xac,0xa2,0x88,0x7b,0xb1,0xd1,0x24,0x4d,0x03,0x9b,0x72};
    std::uint8_t b31_data[32] = {0xa4,0xa9,0x15,0xd0,0x2a,0xd6,0x4c,0xe9,0x1e,0xa7,0x72,0x28,0x64,0xf5,0x49,0x69,0xab,0x3b,0x74,0xfe,0x8e,0xac,0xa2,0x88,0x7b,0xb1,0xd1,0x24,0x4d,0x03,0x9b,0x72};
    bool         cmp31        = true;
    uint256_from_bytes(a, a31_data);
    uint256_from_bytes(b, b31_data);
    if (uint256_equal(a, b) != cmp31)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a32_data[32] = {0x3e,0x7c,0x65,0x67,0x31,0x41,0x97,0x75,0x8c,0x3b,0xa8,0x59,0x23,0xbc,0x91,0x52,0x6d,0x6b,0x98,0x7a,0x73,0x30,0x9b,0x95,0xc2,0x5e,0x11,0x4f,0xff,0x18,0xfe,0x33};
    std::uint8_t b32_data[32] = {0x62,0x01,0xa9,0xd3,0x69,0xac,0x0f,0x03,0xde,0xe0,0xa8,0x43,0xbf,0xe9,0x8f,0x8c,0x05,0x24,0x13,0x7f,0xe3,0x22,0xe9,0x6d,0x33,0xbf,0x91,0x57,0x91,0xd2,0x77,0xf2};
    bool         cmp32        = false;
    uint256_from_bytes(a, a32_data);
    uint256_from_bytes(b, b32_data);
    if (uint256_equal(a, b) != cmp32)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a33_data[32] = {0xa5,0x52,0x9b,0x05,0x66,0x56,0x7b,0xc4,0x62,0x72,0x92,0xf8,0x3f,0x9a,0xa8,0x84,0xe5,0x94,0x09,0xc1,0x45,0x61,0x9f,0xc0,0x17,0xb4,0x83,0x4c,0x37,0x49,0x5c,0x5e};
    std::uint8_t b33_data[32] = {0x05,0x95,0x5f,0xb9,0xf7,0xd1,0x7e,0xbd,0xdf,0x75,0xc8,0x83,0xd0,0x78,0x84,0xb7,0xd9,0x43,0x55,0x41,0x4f,0xe0,0x48,0x02,0xf4,0x35,0xa5,0x73,0x6e,0x8c,0xd9,0x4e};
    bool         cmp33        = false;
    uint256_from_bytes(a, a33_data);
    uint256_from_bytes(b, b33_data);
    if (uint256_equal(a, b) != cmp33)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a34_data[32] = {0x96,0x51,0x32,0xd6,0xf7,0xe1,0x47,0xfd,0x79,0x28,0x1c,0x19,0xcd,0xe3,0x47,0xab,0xe5,0x4c,0x5d,0xe6,0xc3,0x81,0x3c,0xe6,0xb5,0xa2,0x90,0x61,0x6c,0xd9,0xe6,0x2a};
    std::uint8_t b34_data[32] = {0x27,0x85,0x57,0x98,0x39,0x4a,0xfb,0xe9,0x1b,0xea,0x70,0x5e,0xc8,0x79,0xb6,0x63,0x3f,0x9b,0x6b,0xb2,0x72,0xee,0x6a,0x2e,0xf8,0xe4,0xcb,0x5c,0x77,0xd8,0xc5,0x69};
    bool         cmp34        = false;
    uint256_from_bytes(a, a34_data);
    uint256_from_bytes(b, b34_data);
    if (uint256_equal(a, b) != cmp34)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a35_data[32] = {0xe5,0x17,0x4e,0xbd,0xc3,0xc9,0xf7,0xe3,0xd8,0xb4,0xc8,0x31,0xa5,0xb8,0x9b,0x2f,0xb3,0x74,0xfa,0xb6,0xb8,0xc3,0xa4,0xd2,0xd3,0x4d,0x1c,0x0d,0xf1,0x05,0x86,0x67};
    std::uint8_t b35_data[32] = {0xe5,0x17,0x4e,0xbd,0xc3,0xc9,0xf7,0xe3,0xd8,0xb4,0xc8,0x31,0xa5,0xb8,0x9b,0x2f,0xb3,0x74,0xfa,0xb6,0xb8,0xc3,0xa4,0xd2,0xd3,0x4d,0x1c,0x0d,0xf1,0x05,0x86,0x67};
    bool         cmp35        = true;
    uint256_from_bytes(a, a35_data);
    uint256_from_bytes(b, b35_data);
    if (uint256_equal(a, b) != cmp35)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a36_data[32] = {0xf5,0xea,0xd0,0x65,0x07,0x7e,0xf3,0x2a,0x3f,0x3f,0x37,0xea,0x8c,0x08,0x56,0xa4,0x3c,0x19,0xc3,0x15,0x86,0xba,0x22,0xdd,0x79,0xad,0x89,0x99,0x3e,0x0b,0x25,0xcd};
    std::uint8_t b36_data[32] = {0xec,0xd7,0x57,0x0b,0x6c,0xa0,0x64,0x96,0xaa,0xd7,0xc7,0xc0,0x3a,0x53,0xc1,0x76,0x41,0xdb,0x89,0x8e,0x14,0xc2,0x73,0x2a,0x6b,0x86,0x29,0x0b,0xa5,0xac,0xd3,0x41};
    bool         cmp36        = false;
    uint256_from_bytes(a, a36_data);
    uint256_from_bytes(b, b36_data);
    if (uint256_equal(a, b) != cmp36)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a37_data[32] = {0xae,0xbc,0xb0,0xaa,0x5c,0xc0,0xff,0x06,0x6b,0xa9,0x9d,0x01,0xb7,0xe4,0x9f,0x36,0x56,0x8a,0x8c,0x29,0xb2,0x21,0x71,0x39,0x08,0xba,0x9b,0xd9,0x7e,0x31,0x8a,0xd6};
    std::uint8_t b37_data[32] = {0xae,0xbc,0xb0,0xaa,0x5c,0xc0,0xff,0x06,0x6b,0xa9,0x9d,0x01,0xb7,0xe4,0x9f,0x36,0x56,0x8a,0x8c,0x29,0xb2,0x21,0x71,0x39,0x08,0xba,0x9b,0xd9,0x7e,0x31,0x8a,0xd6};
    bool         cmp37        = true;
    uint256_from_bytes(a, a37_data);
    uint256_from_bytes(b, b37_data);
    if (uint256_equal(a, b) != cmp37)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a38_data[32] = {0x77,0x11,0xb7,0x57,0x3b,0x16,0x49,0x43,0x31,0xa5,0x9c,0x4a,0xd1,0xeb,0xd0,0x86,0xc4,0x0f,0x36,0x09,0x4f,0xcc,0x9a,0x5c,0x33,0x4e,0x51,0xaf,0xf8,0x48,0xa9,0x56};
    std::uint8_t b38_data[32] = {0x77,0x11,0xb7,0x57,0x3b,0x16,0x49,0x43,0x31,0xa5,0x9c,0x4a,0xd1,0xeb,0xd0,0x86,0xc4,0x0f,0x36,0x09,0x4f,0xcc,0x9a,0x5c,0x33,0x4e,0x51,0xaf,0xf8,0x48,0xa9,0x56};
    bool         cmp38        = true;
    uint256_from_bytes(a, a38_data);
    uint256_from_bytes(b, b38_data);
    if (uint256_equal(a, b) != cmp38)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a39_data[32] = {0x08,0x2a,0x2f,0x4d,0x77,0xb5,0xab,0xcb,0xbf,0x0e,0x11,0xe0,0x86,0x59,0x22,0x43,0xef,0x95,0xee,0xe8,0xa7,0x08,0x28,0xa7,0x2f,0x7d,0xba,0x08,0x30,0xd0,0xa2,0xb8};
    std::uint8_t b39_data[32] = {0x71,0x43,0x6e,0x1d,0x54,0xea,0x20,0x61,0xfc,0x27,0xd6,0x83,0x5f,0xb6,0xd6,0x25,0xd6,0xd1,0x06,0xfb,0x60,0xed,0x33,0xa0,0xb9,0xb2,0x53,0xe3,0xaa,0x18,0x13,0x45};
    bool         cmp39        = false;
    uint256_from_bytes(a, a39_data);
    uint256_from_bytes(b, b39_data);
    if (uint256_equal(a, b) != cmp39)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a40_data[32] = {0xe2,0x9a,0xac,0xea,0xf4,0x9c,0x9e,0xba,0x6b,0x91,0x1f,0x97,0x59,0xf9,0xbb,0x79,0x14,0xac,0xe1,0xcb,0x47,0xa1,0x64,0xe4,0x14,0x07,0xab,0x33,0x00,0xbc,0x22,0xcb};
    std::uint8_t b40_data[32] = {0xe2,0x9a,0xac,0xea,0xf4,0x9c,0x9e,0xba,0x6b,0x91,0x1f,0x97,0x59,0xf9,0xbb,0x79,0x14,0xac,0xe1,0xcb,0x47,0xa1,0x64,0xe4,0x14,0x07,0xab,0x33,0x00,0xbc,0x22,0xcb};
    bool         cmp40        = true;
    uint256_from_bytes(a, a40_data);
    uint256_from_bytes(b, b40_data);
    if (uint256_equal(a, b) != cmp40)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a41_data[32] = {0xeb,0x64,0xc5,0xc4,0x8a,0xa1,0xa5,0x9c,0x5f,0x6a,0x35,0xd9,0x32,0x1a,0x6e,0xc1,0x79,0x34,0xf0,0xb8,0xb4,0x8b,0xb0,0x75,0x0c,0x9c,0x20,0xef,0x16,0x77,0x74,0xef};
    std::uint8_t b41_data[32] = {0xa1,0xb4,0x9b,0xf7,0x07,0xc0,0x90,0x9c,0x79,0x7b,0x15,0x38,0xe5,0xa1,0x5b,0x79,0xbc,0xc0,0xfd,0x98,0x5d,0x3f,0x69,0xce,0x52,0xc4,0x64,0x1b,0x31,0x6a,0x2a,0x12};
    bool         cmp41        = false;
    uint256_from_bytes(a, a41_data);
    uint256_from_bytes(b, b41_data);
    if (uint256_equal(a, b) != cmp41)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a42_data[32] = {0x76,0xcc,0x05,0x73,0x08,0xec,0x37,0x9a,0x60,0x25,0x33,0xdc,0x0a,0x68,0x01,0x3d,0x67,0x9f,0x2d,0x9e,0xc4,0x44,0x5a,0xae,0xa0,0x1a,0xc2,0x3a,0xcf,0xd3,0xbb,0x74};
    std::uint8_t b42_data[32] = {0x76,0xcc,0x05,0x73,0x08,0xec,0x37,0x9a,0x60,0x25,0x33,0xdc,0x0a,0x68,0x01,0x3d,0x67,0x9f,0x2d,0x9e,0xc4,0x44,0x5a,0xae,0xa0,0x1a,0xc2,0x3a,0xcf,0xd3,0xbb,0x74};
    bool         cmp42        = true;
    uint256_from_bytes(a, a42_data);
    uint256_from_bytes(b, b42_data);
    if (uint256_equal(a, b) != cmp42)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a43_data[32] = {0x1b,0x75,0x7b,0x20,0x3b,0xde,0xa8,0xc3,0xd3,0x75,0xef,0xf1,0x06,0x35,0xaf,0xef,0x10,0xb9,0x9a,0xc9,0xf1,0x78,0xd7,0x7f,0xf2,0x4d,0x04,0xfd,0xa2,0x4c,0x84,0x07};
    std::uint8_t b43_data[32] = {0x1b,0x75,0x7b,0x20,0x3b,0xde,0xa8,0xc3,0xd3,0x75,0xef,0xf1,0x06,0x35,0xaf,0xef,0x10,0xb9,0x9a,0xc9,0xf1,0x78,0xd7,0x7f,0xf2,0x4d,0x04,0xfd,0xa2,0x4c,0x84,0x07};
    bool         cmp43        = true;
    uint256_from_bytes(a, a43_data);
    uint256_from_bytes(b, b43_data);
    if (uint256_equal(a, b) != cmp43)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a44_data[32] = {0xa6,0x48,0xa5,0x8c,0x10,0x92,0x57,0xf7,0x68,0x62,0xbf,0x79,0x3f,0x4f,0x8b,0x9d,0x28,0xf1,0xa8,0x1b,0xc0,0xbd,0x1d,0x84,0x64,0x45,0x7e,0xa4,0x32,0x83,0x06,0x89};
    std::uint8_t b44_data[32] = {0xe2,0x2b,0x64,0xa6,0x6d,0x32,0xa9,0x01,0xfa,0xf2,0x0a,0xc0,0x29,0x23,0x22,0xd3,0x53,0x64,0xe6,0x4d,0x8b,0x6b,0xfe,0xae,0x8d,0x76,0xd7,0xa1,0x7b,0x50,0x07,0x9e};
    bool         cmp44        = false;
    uint256_from_bytes(a, a44_data);
    uint256_from_bytes(b, b44_data);
    if (uint256_equal(a, b) != cmp44)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a45_data[32] = {0xc2,0x72,0xf5,0xa7,0xaa,0x17,0xc5,0x7c,0xc6,0x1c,0x96,0xdb,0xd8,0xd4,0x25,0x0d,0x89,0xdf,0x5e,0x79,0xbf,0x7b,0x6c,0x6c,0x3c,0x24,0x96,0xeb,0xac,0x92,0x61,0xf1};
    std::uint8_t b45_data[32] = {0xc2,0x72,0xf5,0xa7,0xaa,0x17,0xc5,0x7c,0xc6,0x1c,0x96,0xdb,0xd8,0xd4,0x25,0x0d,0x89,0xdf,0x5e,0x79,0xbf,0x7b,0x6c,0x6c,0x3c,0x24,0x96,0xeb,0xac,0x92,0x61,0xf1};
    bool         cmp45        = true;
    uint256_from_bytes(a, a45_data);
    uint256_from_bytes(b, b45_data);
    if (uint256_equal(a, b) != cmp45)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a46_data[32] = {0xfe,0x11,0x1e,0xbc,0x40,0x6c,0x61,0x32,0x65,0x64,0xd1,0x34,0x10,0x97,0x00,0x46,0x53,0x8a,0xe1,0xc1,0x30,0x31,0x29,0x32,0x94,0x0a,0x35,0x37,0xe8,0x56,0x64,0x31};
    std::uint8_t b46_data[32] = {0xfe,0x11,0x1e,0xbc,0x40,0x6c,0x61,0x32,0x65,0x64,0xd1,0x34,0x10,0x97,0x00,0x46,0x53,0x8a,0xe1,0xc1,0x30,0x31,0x29,0x32,0x94,0x0a,0x35,0x37,0xe8,0x56,0x64,0x31};
    bool         cmp46        = true;
    uint256_from_bytes(a, a46_data);
    uint256_from_bytes(b, b46_data);
    if (uint256_equal(a, b) != cmp46)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a47_data[32] = {0xdd,0xba,0x85,0x47,0x83,0x3e,0x46,0x9f,0x5f,0x4a,0xeb,0xeb,0x13,0x3a,0xd7,0x3d,0xee,0x1f,0xdd,0xe0,0x31,0xb4,0x93,0x2c,0x95,0x4c,0x2f,0xc1,0xd3,0xf2,0xe5,0x2d};
    std::uint8_t b47_data[32] = {0xdd,0xba,0x85,0x47,0x83,0x3e,0x46,0x9f,0x5f,0x4a,0xeb,0xeb,0x13,0x3a,0xd7,0x3d,0xee,0x1f,0xdd,0xe0,0x31,0xb4,0x93,0x2c,0x95,0x4c,0x2f,0xc1,0xd3,0xf2,0xe5,0x2d};
    bool         cmp47        = true;
    uint256_from_bytes(a, a47_data);
    uint256_from_bytes(b, b47_data);
    if (uint256_equal(a, b) != cmp47)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a48_data[32] = {0xff,0xf7,0xba,0x0d,0x34,0x37,0xcc,0xaa,0x0b,0x4e,0x7f,0x7c,0x24,0x30,0xca,0x6d,0x57,0x0b,0x53,0x4d,0x5e,0x63,0xaf,0x16,0x09,0x96,0x9e,0x7c,0x37,0xb7,0x9c,0x48};
    std::uint8_t b48_data[32] = {0x13,0xf3,0x88,0x70,0x4f,0xec,0x0f,0x40,0x9e,0xfa,0xc2,0x92,0x2f,0x65,0xab,0x4e,0x5f,0x2e,0xe4,0x0d,0xad,0xa6,0x5c,0xc4,0x68,0xb3,0xe3,0xaa,0x53,0xc6,0x9b,0x0a};
    bool         cmp48        = false;
    uint256_from_bytes(a, a48_data);
    uint256_from_bytes(b, b48_data);
    if (uint256_equal(a, b) != cmp48)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a49_data[32] = {0xcb,0xbc,0x6c,0x94,0x19,0xf4,0x8c,0x75,0x68,0x7d,0xd5,0x12,0x10,0x32,0x88,0x8d,0x7b,0xc7,0x1d,0xf3,0x8c,0x4c,0xaa,0x83,0x7e,0xe1,0x4b,0x90,0xcb,0x97,0x8b,0xe3};
    std::uint8_t b49_data[32] = {0xcb,0xbc,0x6c,0x94,0x19,0xf4,0x8c,0x75,0x68,0x7d,0xd5,0x12,0x10,0x32,0x88,0x8d,0x7b,0xc7,0x1d,0xf3,0x8c,0x4c,0xaa,0x83,0x7e,0xe1,0x4b,0x90,0xcb,0x97,0x8b,0xe3};
    bool         cmp49        = true;
    uint256_from_bytes(a, a49_data);
    uint256_from_bytes(b, b49_data);
    if (uint256_equal(a, b) != cmp49)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a50_data[32] = {0x0d,0x25,0xf9,0x54,0xf4,0x04,0x2f,0x1e,0x6a,0xf7,0xea,0x31,0x4e,0xbe,0x98,0x80,0xaa,0xf5,0xa8,0x6e,0x48,0x86,0x6d,0x48,0xfc,0xfd,0x36,0xd1,0x68,0xe7,0xed,0x23};
    std::uint8_t b50_data[32] = {0x67,0xac,0x56,0xf8,0xba,0x60,0x49,0x1e,0x64,0x06,0xf4,0x58,0x32,0x7b,0xcd,0xa3,0xa4,0xfc,0x86,0x21,0x5d,0x20,0xc6,0xa6,0xcd,0x5e,0x4a,0xa0,0xff,0x22,0x82,0xe6};
    bool         cmp50        = false;
    uint256_from_bytes(a, a50_data);
    uint256_from_bytes(b, b50_data);
    if (uint256_equal(a, b) != cmp50)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a51_data[32] = {0x63,0x4d,0x19,0x52,0xa2,0xe8,0xfe,0xc0,0xed,0x19,0x55,0x7a,0x9b,0x8e,0x9a,0x82,0x0d,0xa9,0xf4,0x4a,0x50,0x84,0xc6,0x3f,0x7b,0x94,0x9e,0x54,0xe9,0xad,0x2b,0xc7};
    std::uint8_t b51_data[32] = {0xd4,0x45,0xa5,0x3e,0x32,0x34,0x75,0x2b,0xd8,0xaa,0x7b,0xe3,0x9d,0x5e,0xe2,0xf9,0x67,0x8c,0x4c,0xb9,0x9e,0xfd,0x55,0xd2,0x38,0xd9,0xe9,0xab,0xdb,0x49,0x52,0x44};
    bool         cmp51        = false;
    uint256_from_bytes(a, a51_data);
    uint256_from_bytes(b, b51_data);
    if (uint256_equal(a, b) != cmp51)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a52_data[32] = {0x62,0x32,0x0f,0xa3,0x28,0x0f,0x00,0x5d,0x84,0x94,0x9a,0xab,0xf0,0x44,0xc0,0x32,0x66,0x55,0xb9,0xf0,0x0a,0xad,0xac,0xf0,0x37,0xd7,0xd1,0x90,0x90,0xbf,0xd7,0x92};
    std::uint8_t b52_data[32] = {0x31,0x4d,0xf3,0x86,0xe5,0xb5,0x20,0x6e,0xd0,0xce,0x6b,0xc4,0xb9,0x91,0xe9,0x61,0xf8,0x7f,0x4a,0x4d,0x3f,0x3f,0x40,0x72,0x26,0x43,0x7a,0x8e,0x1f,0x80,0xa4,0xe8};
    bool         cmp52        = false;
    uint256_from_bytes(a, a52_data);
    uint256_from_bytes(b, b52_data);
    if (uint256_equal(a, b) != cmp52)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a53_data[32] = {0x3f,0xcf,0x6d,0x85,0x95,0x26,0xe3,0xd0,0x4e,0xe6,0xf4,0xff,0x6b,0x89,0xd4,0x63,0xa6,0x26,0xb0,0x97,0x4e,0x64,0x0c,0xd4,0xc7,0x30,0xa7,0xcb,0xa0,0x85,0xda,0x1f};
    std::uint8_t b53_data[32] = {0x3f,0xcf,0x6d,0x85,0x95,0x26,0xe3,0xd0,0x4e,0xe6,0xf4,0xff,0x6b,0x89,0xd4,0x63,0xa6,0x26,0xb0,0x97,0x4e,0x64,0x0c,0xd4,0xc7,0x30,0xa7,0xcb,0xa0,0x85,0xda,0x1f};
    bool         cmp53        = true;
    uint256_from_bytes(a, a53_data);
    uint256_from_bytes(b, b53_data);
    if (uint256_equal(a, b) != cmp53)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a54_data[32] = {0x5b,0xcb,0x93,0x70,0x20,0xe2,0x7c,0x17,0x11,0x2e,0xd1,0xdf,0x1b,0x69,0x56,0x7e,0x66,0x7c,0xd6,0x0b,0x79,0x24,0xde,0xde,0xcf,0x7e,0xda,0x11,0x2d,0xf8,0x3c,0x66};
    std::uint8_t b54_data[32] = {0x0a,0x6f,0xb1,0x54,0xa8,0x37,0x6d,0xcd,0x82,0x99,0xed,0x6e,0x81,0x1c,0x8f,0xa7,0x71,0x24,0xc2,0x05,0xcd,0x62,0x5a,0x7f,0x17,0x7a,0x83,0x34,0x5d,0x86,0x6b,0x34};
    bool         cmp54        = false;
    uint256_from_bytes(a, a54_data);
    uint256_from_bytes(b, b54_data);
    if (uint256_equal(a, b) != cmp54)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a55_data[32] = {0x14,0x78,0xc7,0xb9,0x82,0xf0,0x77,0x9d,0xb8,0x6b,0xb4,0xd6,0xc7,0x13,0x28,0x91,0x50,0x50,0x56,0x52,0xbb,0xc5,0x5c,0x33,0xec,0x10,0x72,0xee,0x15,0x0d,0xbf,0x6a};
    std::uint8_t b55_data[32] = {0x22,0xdd,0x11,0x3c,0xc8,0xc4,0x22,0x76,0xf3,0x6c,0x15,0x75,0xa7,0x1a,0x56,0xc6,0x60,0xbb,0x9a,0xee,0xe5,0x16,0x09,0x31,0x81,0x01,0x2a,0xd6,0xc0,0x86,0xee,0x53};
    bool         cmp55        = false;
    uint256_from_bytes(a, a55_data);
    uint256_from_bytes(b, b55_data);
    if (uint256_equal(a, b) != cmp55)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a56_data[32] = {0xd0,0xcc,0xe8,0x93,0xe7,0xb2,0x27,0xe9,0x46,0x65,0xea,0x19,0x9d,0x10,0x6a,0x37,0xe5,0x83,0x76,0xfb,0x52,0xe7,0x1c,0xf8,0x28,0xa4,0xfb,0xd7,0x40,0x91,0x8a,0x58};
    std::uint8_t b56_data[32] = {0x97,0x85,0xf4,0xf8,0x35,0x54,0xad,0xa8,0x7a,0xe8,0x54,0x84,0xeb,0x7f,0x14,0x14,0xf6,0xde,0x2f,0xbe,0x80,0x91,0x5a,0xaf,0x41,0x10,0xb8,0xbc,0x24,0xc1,0x27,0x6c};
    bool         cmp56        = false;
    uint256_from_bytes(a, a56_data);
    uint256_from_bytes(b, b56_data);
    if (uint256_equal(a, b) != cmp56)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a57_data[32] = {0xc8,0xed,0x32,0x13,0xca,0xc8,0xa6,0x1c,0x2b,0x32,0xad,0xa9,0x60,0x78,0xa4,0x06,0xe5,0x39,0xcb,0x16,0x53,0xec,0x4b,0x93,0xad,0xff,0x81,0x65,0x47,0x37,0xfe,0xd1};
    std::uint8_t b57_data[32] = {0xc8,0xed,0x32,0x13,0xca,0xc8,0xa6,0x1c,0x2b,0x32,0xad,0xa9,0x60,0x78,0xa4,0x06,0xe5,0x39,0xcb,0x16,0x53,0xec,0x4b,0x93,0xad,0xff,0x81,0x65,0x47,0x37,0xfe,0xd1};
    bool         cmp57        = true;
    uint256_from_bytes(a, a57_data);
    uint256_from_bytes(b, b57_data);
    if (uint256_equal(a, b) != cmp57)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a58_data[32] = {0x93,0xcd,0xe6,0x09,0x5e,0x73,0x25,0x2b,0xfd,0x91,0x4b,0x0e,0x60,0x30,0x7b,0x75,0x43,0xc6,0xed,0x1e,0x5f,0x18,0x69,0x04,0xcc,0x34,0x24,0x16,0xbc,0xe8,0x87,0x96};
    std::uint8_t b58_data[32] = {0xbb,0xa8,0x6d,0xf7,0x50,0x09,0xc0,0xa9,0xe5,0x4e,0x19,0xe5,0xa9,0xe8,0x25,0x81,0xed,0xaf,0x80,0xf3,0x95,0xfb,0x98,0xf9,0xde,0xcb,0xc1,0x0b,0xfb,0xeb,0x0a,0x98};
    bool         cmp58        = false;
    uint256_from_bytes(a, a58_data);
    uint256_from_bytes(b, b58_data);
    if (uint256_equal(a, b) != cmp58)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a59_data[32] = {0x83,0x3e,0xdd,0x4b,0x6a,0xed,0x88,0x72,0x6e,0xa6,0xd0,0x5e,0xa0,0x28,0x80,0x56,0x9d,0xb5,0x96,0x58,0x4a,0x7d,0x1d,0xbc,0x26,0x3c,0xc4,0xdc,0x38,0xbd,0x3c,0x69};
    std::uint8_t b59_data[32] = {0x0b,0xab,0x5f,0x9f,0xa7,0x32,0x1d,0x31,0x9c,0xce,0x12,0xd5,0x3a,0x2d,0xb0,0x0a,0x7d,0x07,0x6c,0x0b,0x21,0xcc,0x47,0x51,0x0c,0x3b,0x12,0x66,0xe5,0x42,0x45,0x3d};
    bool         cmp59        = false;
    uint256_from_bytes(a, a59_data);
    uint256_from_bytes(b, b59_data);
    if (uint256_equal(a, b) != cmp59)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a60_data[32] = {0x88,0xbb,0xa3,0x17,0x5b,0x6e,0x48,0xb0,0x85,0xe9,0x25,0x1c,0x1b,0x3a,0x95,0x3c,0x4d,0xc1,0xd3,0x27,0x5a,0xde,0xd3,0xca,0x91,0x2e,0xda,0x41,0x00,0xab,0x68,0xb8};
    std::uint8_t b60_data[32] = {0x88,0xbb,0xa3,0x17,0x5b,0x6e,0x48,0xb0,0x85,0xe9,0x25,0x1c,0x1b,0x3a,0x95,0x3c,0x4d,0xc1,0xd3,0x27,0x5a,0xde,0xd3,0xca,0x91,0x2e,0xda,0x41,0x00,0xab,0x68,0xb8};
    bool         cmp60        = true;
    uint256_from_bytes(a, a60_data);
    uint256_from_bytes(b, b60_data);
    if (uint256_equal(a, b) != cmp60)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a61_data[32] = {0x45,0x0f,0x00,0x2a,0xc8,0x3b,0x62,0x69,0xaa,0x5c,0x68,0x17,0xdf,0x0c,0x92,0xb9,0x25,0x0a,0x82,0xa2,0xa3,0x61,0xbc,0xa2,0x10,0x4c,0x96,0x8a,0x18,0x86,0xa7,0xba};
    std::uint8_t b61_data[32] = {0x45,0x0f,0x00,0x2a,0xc8,0x3b,0x62,0x69,0xaa,0x5c,0x68,0x17,0xdf,0x0c,0x92,0xb9,0x25,0x0a,0x82,0xa2,0xa3,0x61,0xbc,0xa2,0x10,0x4c,0x96,0x8a,0x18,0x86,0xa7,0xba};
    bool         cmp61        = true;
    uint256_from_bytes(a, a61_data);
    uint256_from_bytes(b, b61_data);
    if (uint256_equal(a, b) != cmp61)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a62_data[32] = {0xff,0x21,0xdd,0x5a,0x39,0xd7,0xc1,0x40,0x2c,0xe6,0x78,0xfe,0x73,0xd6,0x34,0x26,0xa7,0xd0,0xe5,0x97,0xbd,0xe3,0xa6,0xe4,0x14,0x9a,0x3e,0x17,0x77,0x1b,0xa4,0xba};
    std::uint8_t b62_data[32] = {0x43,0xea,0x74,0x71,0xf8,0xcd,0xe5,0x9b,0x85,0xf3,0x5c,0x2e,0xea,0xd2,0x8c,0x16,0xc9,0xd7,0xdc,0x2a,0xaf,0x8c,0x3e,0x74,0x6f,0xa1,0x26,0xa8,0xad,0xe2,0x56,0x55};
    bool         cmp62        = false;
    uint256_from_bytes(a, a62_data);
    uint256_from_bytes(b, b62_data);
    if (uint256_equal(a, b) != cmp62)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a63_data[32] = {0xb9,0x80,0xea,0x1e,0xf4,0xa8,0x87,0x53,0x6f,0xed,0x41,0xd7,0x06,0xc9,0xcd,0x95,0xdb,0x86,0x9c,0x8a,0x01,0xa2,0x3b,0x4e,0xb2,0x97,0x1b,0x77,0x87,0xd6,0x99,0x91};
    std::uint8_t b63_data[32] = {0x95,0xd8,0x56,0x75,0x9f,0x64,0x28,0xef,0x64,0x3d,0x79,0xf1,0x36,0x43,0x69,0x24,0xca,0x09,0x2b,0x18,0x4e,0xc8,0xc2,0x23,0xe2,0x7f,0x8b,0xe8,0x92,0x01,0xd5,0x5a};
    bool         cmp63        = false;
    uint256_from_bytes(a, a63_data);
    uint256_from_bytes(b, b63_data);
    if (uint256_equal(a, b) != cmp63)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a64_data[32] = {0x29,0x6c,0x76,0x4d,0xed,0xcf,0x97,0x5c,0x9f,0x39,0x5e,0xf1,0x1b,0x4f,0x46,0x3f,0x1c,0xa5,0x05,0xc1,0x06,0xe3,0x15,0xe3,0x08,0x6d,0x06,0xd8,0x25,0x04,0x2c,0x3d};
    std::uint8_t b64_data[32] = {0x62,0x43,0x83,0x62,0xf1,0xbf,0x55,0xed,0xb6,0x14,0x3f,0x78,0xea,0x16,0xb1,0x8f,0xc1,0x7a,0x4f,0x81,0xde,0x27,0xa2,0x4e,0xe1,0x34,0xf9,0xf8,0x10,0xe1,0xfe,0xc9};
    bool         cmp64        = false;
    uint256_from_bytes(a, a64_data);
    uint256_from_bytes(b, b64_data);
    if (uint256_equal(a, b) != cmp64)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a65_data[32] = {0x49,0x90,0xc2,0x24,0xa1,0xdb,0xbd,0x89,0xa1,0xac,0x60,0x36,0xc0,0x5d,0x7b,0x62,0xd3,0x37,0x26,0x4b,0x16,0x64,0x6a,0x40,0xa2,0x59,0x25,0x59,0xc0,0xf6,0x21,0xad};
    std::uint8_t b65_data[32] = {0x49,0x90,0xc2,0x24,0xa1,0xdb,0xbd,0x89,0xa1,0xac,0x60,0x36,0xc0,0x5d,0x7b,0x62,0xd3,0x37,0x26,0x4b,0x16,0x64,0x6a,0x40,0xa2,0x59,0x25,0x59,0xc0,0xf6,0x21,0xad};
    bool         cmp65        = true;
    uint256_from_bytes(a, a65_data);
    uint256_from_bytes(b, b65_data);
    if (uint256_equal(a, b) != cmp65)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a66_data[32] = {0x80,0xf4,0xed,0xd8,0x9a,0x1d,0x38,0x76,0xf6,0xc8,0xa6,0x4a,0xc4,0xec,0xbf,0xa2,0x52,0x21,0xcb,0xda,0xe9,0x0b,0xa8,0x87,0x5e,0x36,0xd7,0x60,0xc2,0x85,0xa8,0xc6};
    std::uint8_t b66_data[32] = {0x07,0xff,0xe3,0x8e,0x69,0xb5,0x2f,0xc2,0xc9,0xff,0x90,0x90,0x07,0xee,0x64,0xfe,0xbe,0xe3,0x3d,0x4a,0x9e,0x47,0x53,0x94,0x49,0xa3,0x59,0x64,0xd9,0xf3,0xdd,0x45};
    bool         cmp66        = false;
    uint256_from_bytes(a, a66_data);
    uint256_from_bytes(b, b66_data);
    if (uint256_equal(a, b) != cmp66)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a67_data[32] = {0x59,0x09,0xa9,0x58,0x01,0x1d,0xd8,0xb3,0x0d,0xd0,0x9e,0x51,0xfa,0x55,0x68,0x35,0xc0,0x21,0xfa,0x1b,0xc3,0x1e,0x4b,0x97,0x49,0xd0,0x4c,0xe5,0x33,0xb8,0x93,0xa5};
    std::uint8_t b67_data[32] = {0x28,0xad,0x5d,0xc9,0xf1,0xa1,0x75,0x00,0x93,0xf8,0x4a,0xde,0x42,0xb5,0x0c,0x7c,0x83,0xe0,0x3b,0x8d,0xd4,0xf3,0x31,0x8e,0xf5,0x0b,0x7e,0x1d,0x58,0xe1,0x29,0x0d};
    bool         cmp67        = false;
    uint256_from_bytes(a, a67_data);
    uint256_from_bytes(b, b67_data);
    if (uint256_equal(a, b) != cmp67)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a68_data[32] = {0x4d,0x9a,0xa6,0x96,0x34,0xc4,0x11,0xc3,0x5f,0x38,0x1d,0x79,0x06,0x71,0xce,0x23,0xa5,0x57,0x41,0xcb,0xe3,0x71,0x61,0x3e,0x6c,0x10,0xb6,0x01,0x16,0x0f,0x6d,0x6e};
    std::uint8_t b68_data[32] = {0x4d,0x9a,0xa6,0x96,0x34,0xc4,0x11,0xc3,0x5f,0x38,0x1d,0x79,0x06,0x71,0xce,0x23,0xa5,0x57,0x41,0xcb,0xe3,0x71,0x61,0x3e,0x6c,0x10,0xb6,0x01,0x16,0x0f,0x6d,0x6e};
    bool         cmp68        = true;
    uint256_from_bytes(a, a68_data);
    uint256_from_bytes(b, b68_data);
    if (uint256_equal(a, b) != cmp68)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a69_data[32] = {0xb2,0x52,0x01,0xe9,0xe2,0x97,0x96,0x19,0xa4,0x88,0x0c,0x45,0x76,0x46,0xcf,0x57,0x55,0x84,0x8b,0xff,0x20,0x45,0x46,0x43,0x3b,0x24,0x6b,0x47,0x94,0x44,0x78,0x57};
    std::uint8_t b69_data[32] = {0x32,0x07,0xd5,0xa3,0x1a,0x04,0xf2,0x80,0xa8,0x6c,0x1f,0xcf,0xf6,0x5e,0xe8,0xfc,0x2a,0x23,0x53,0x4a,0x1a,0x0f,0xfe,0xd5,0xfe,0xb3,0x6d,0x43,0xba,0x8e,0x33,0x38};
    bool         cmp69        = false;
    uint256_from_bytes(a, a69_data);
    uint256_from_bytes(b, b69_data);
    if (uint256_equal(a, b) != cmp69)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a70_data[32] = {0x46,0x19,0x1a,0xa0,0x6f,0x57,0x1d,0x36,0x4c,0x22,0xb1,0xf4,0xbb,0xb9,0x10,0x47,0x4d,0x56,0xc5,0xae,0xcb,0x7d,0xc4,0x5a,0x25,0xf8,0x3e,0x61,0xfb,0xdc,0x77,0x3b};
    std::uint8_t b70_data[32] = {0x63,0x6a,0x54,0x79,0xe2,0x9f,0x9e,0xcb,0x34,0xd9,0x82,0xfb,0x47,0xe2,0xcc,0x36,0x1b,0x5b,0xd0,0x42,0xe9,0x51,0xac,0xba,0xa3,0x52,0xb6,0xb5,0x1b,0xf9,0xb6,0x83};
    bool         cmp70        = false;
    uint256_from_bytes(a, a70_data);
    uint256_from_bytes(b, b70_data);
    if (uint256_equal(a, b) != cmp70)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a71_data[32] = {0xbc,0xfd,0x52,0x7b,0x9a,0x8c,0xa8,0x91,0x41,0xd8,0xbf,0x61,0x24,0x4d,0xd3,0x7f,0x05,0xa9,0x7a,0xab,0x76,0x99,0x78,0x19,0x4b,0xd4,0xa2,0x1c,0xa1,0xe3,0x81,0xf9};
    std::uint8_t b71_data[32] = {0xad,0xfa,0x09,0xb0,0x3a,0x85,0xee,0xd0,0xda,0x39,0xc4,0xea,0x95,0x71,0x62,0x3c,0xb3,0x38,0x58,0xa1,0xa4,0x45,0xf3,0x05,0xc6,0x28,0x08,0x7d,0xe0,0xaa,0xda,0xba};
    bool         cmp71        = false;
    uint256_from_bytes(a, a71_data);
    uint256_from_bytes(b, b71_data);
    if (uint256_equal(a, b) != cmp71)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a72_data[32] = {0xe5,0x0d,0xf5,0x23,0x19,0x0d,0xcc,0x94,0xb3,0x5d,0xcf,0x68,0xa0,0xd6,0xc1,0xfe,0x42,0x82,0xc8,0x43,0x50,0x21,0xb4,0x20,0x6e,0xba,0x35,0xe0,0x74,0x32,0xf7,0x9d};
    std::uint8_t b72_data[32] = {0xe5,0x0d,0xf5,0x23,0x19,0x0d,0xcc,0x94,0xb3,0x5d,0xcf,0x68,0xa0,0xd6,0xc1,0xfe,0x42,0x82,0xc8,0x43,0x50,0x21,0xb4,0x20,0x6e,0xba,0x35,0xe0,0x74,0x32,0xf7,0x9d};
    bool         cmp72        = true;
    uint256_from_bytes(a, a72_data);
    uint256_from_bytes(b, b72_data);
    if (uint256_equal(a, b) != cmp72)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a73_data[32] = {0x8b,0x19,0xa2,0xb6,0x40,0x50,0x28,0x45,0x09,0xc3,0xe7,0xc0,0x1b,0x3b,0xb8,0x90,0xf9,0x80,0xaa,0xe3,0xe8,0x7f,0x44,0xb1,0x7d,0x66,0x2a,0x32,0xd4,0xf5,0x86,0x92};
    std::uint8_t b73_data[32] = {0x8b,0x19,0xa2,0xb6,0x40,0x50,0x28,0x45,0x09,0xc3,0xe7,0xc0,0x1b,0x3b,0xb8,0x90,0xf9,0x80,0xaa,0xe3,0xe8,0x7f,0x44,0xb1,0x7d,0x66,0x2a,0x32,0xd4,0xf5,0x86,0x92};
    bool         cmp73        = true;
    uint256_from_bytes(a, a73_data);
    uint256_from_bytes(b, b73_data);
    if (uint256_equal(a, b) != cmp73)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a74_data[32] = {0x66,0x51,0xb3,0xc4,0x61,0xc0,0x0c,0xbe,0x46,0x3c,0x46,0x50,0x40,0xa1,0x11,0xb9,0x0e,0x7e,0x89,0x94,0xa3,0x37,0xb5,0xa6,0x5b,0x00,0x47,0x53,0x9d,0x2f,0x41,0x16};
    std::uint8_t b74_data[32] = {0x66,0x51,0xb3,0xc4,0x61,0xc0,0x0c,0xbe,0x46,0x3c,0x46,0x50,0x40,0xa1,0x11,0xb9,0x0e,0x7e,0x89,0x94,0xa3,0x37,0xb5,0xa6,0x5b,0x00,0x47,0x53,0x9d,0x2f,0x41,0x16};
    bool         cmp74        = true;
    uint256_from_bytes(a, a74_data);
    uint256_from_bytes(b, b74_data);
    if (uint256_equal(a, b) != cmp74)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a75_data[32] = {0x2a,0x1e,0xdb,0x8c,0x36,0x46,0x78,0x38,0x76,0x4d,0x45,0x29,0x64,0x57,0xab,0xc6,0xf5,0xfa,0x5d,0x74,0xcd,0x2e,0x46,0x76,0xfe,0x85,0xdf,0xb1,0x38,0x0a,0xb1,0xd7};
    std::uint8_t b75_data[32] = {0x2a,0x1e,0xdb,0x8c,0x36,0x46,0x78,0x38,0x76,0x4d,0x45,0x29,0x64,0x57,0xab,0xc6,0xf5,0xfa,0x5d,0x74,0xcd,0x2e,0x46,0x76,0xfe,0x85,0xdf,0xb1,0x38,0x0a,0xb1,0xd7};
    bool         cmp75        = true;
    uint256_from_bytes(a, a75_data);
    uint256_from_bytes(b, b75_data);
    if (uint256_equal(a, b) != cmp75)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a76_data[32] = {0xd4,0xd1,0xe9,0x69,0x87,0xd8,0x89,0x17,0x23,0xf1,0x5d,0xdf,0xf1,0x4f,0x10,0xcb,0xc8,0xb6,0xbe,0x1f,0x53,0x1f,0x98,0xd1,0xe7,0xe2,0xe6,0x07,0x90,0x88,0xec,0x8a};
    std::uint8_t b76_data[32] = {0xd4,0xd1,0xe9,0x69,0x87,0xd8,0x89,0x17,0x23,0xf1,0x5d,0xdf,0xf1,0x4f,0x10,0xcb,0xc8,0xb6,0xbe,0x1f,0x53,0x1f,0x98,0xd1,0xe7,0xe2,0xe6,0x07,0x90,0x88,0xec,0x8a};
    bool         cmp76        = true;
    uint256_from_bytes(a, a76_data);
    uint256_from_bytes(b, b76_data);
    if (uint256_equal(a, b) != cmp76)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a77_data[32] = {0x88,0xd6,0x6a,0x76,0xca,0xab,0x2b,0x8d,0x67,0x09,0x36,0x77,0xe7,0x72,0x43,0x6e,0x35,0x62,0xef,0xe9,0x27,0x15,0x81,0x8d,0xc8,0xee,0x3c,0x6e,0x58,0xb0,0x8f,0x1f};
    std::uint8_t b77_data[32] = {0xe1,0xf7,0x7a,0x88,0xab,0xd5,0xa1,0xae,0x70,0x47,0x2e,0xc8,0xd6,0xdb,0x01,0x06,0xbd,0xed,0xf0,0xd4,0x14,0x20,0x1d,0x4d,0x87,0xe2,0x36,0x71,0x36,0x8d,0xc5,0xbf};
    bool         cmp77        = false;
    uint256_from_bytes(a, a77_data);
    uint256_from_bytes(b, b77_data);
    if (uint256_equal(a, b) != cmp77)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a78_data[32] = {0x8e,0xa4,0xdc,0x66,0x7e,0x3a,0x46,0xa3,0x79,0x26,0x5f,0xef,0x23,0xab,0xac,0x2e,0xd3,0xb9,0xcd,0x98,0x3b,0xf2,0xf1,0x08,0x6b,0x46,0x15,0x9a,0x43,0xb5,0xe6,0x70};
    std::uint8_t b78_data[32] = {0x7f,0x88,0x70,0xa9,0x3f,0x1e,0xfd,0x5b,0x7d,0xca,0x92,0x02,0xb3,0x4e,0xd4,0xfa,0x24,0xf8,0xc3,0x85,0xe7,0xcc,0x72,0x15,0x77,0x93,0x7b,0x86,0x7b,0xff,0xb6,0xa4};
    bool         cmp78        = false;
    uint256_from_bytes(a, a78_data);
    uint256_from_bytes(b, b78_data);
    if (uint256_equal(a, b) != cmp78)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a79_data[32] = {0xaa,0x51,0x22,0xf7,0x7f,0x63,0x23,0xa3,0x90,0x04,0x85,0x42,0xb2,0x25,0x8e,0x57,0x77,0xcc,0x40,0xda,0x52,0x18,0x58,0xf4,0xd7,0x3c,0x8a,0x36,0x29,0x0d,0x2e,0xc3};
    std::uint8_t b79_data[32] = {0xad,0x0a,0xd3,0x87,0xf5,0xea,0xc4,0xc1,0xff,0xfc,0xbf,0xf7,0x6b,0x37,0x94,0x13,0x6d,0x02,0x27,0xc2,0x5f,0xfd,0x3d,0x40,0x77,0x3c,0x2b,0x1a,0xd7,0x2f,0x53,0x7c};
    bool         cmp79        = false;
    uint256_from_bytes(a, a79_data);
    uint256_from_bytes(b, b79_data);
    if (uint256_equal(a, b) != cmp79)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a80_data[32] = {0x82,0xb8,0x5b,0xb8,0x18,0x0e,0xcb,0x0d,0xfb,0x51,0x85,0x04,0xcf,0x00,0x61,0xca,0x54,0x98,0xc0,0x04,0xff,0xbd,0x8d,0x4a,0xee,0x76,0x53,0xc9,0xbc,0x8d,0xf8,0x72};
    std::uint8_t b80_data[32] = {0x82,0xb8,0x5b,0xb8,0x18,0x0e,0xcb,0x0d,0xfb,0x51,0x85,0x04,0xcf,0x00,0x61,0xca,0x54,0x98,0xc0,0x04,0xff,0xbd,0x8d,0x4a,0xee,0x76,0x53,0xc9,0xbc,0x8d,0xf8,0x72};
    bool         cmp80        = true;
    uint256_from_bytes(a, a80_data);
    uint256_from_bytes(b, b80_data);
    if (uint256_equal(a, b) != cmp80)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a81_data[32] = {0x7e,0x65,0x1b,0xa5,0xd3,0xe6,0x61,0x59,0x5a,0xec,0xfa,0xbb,0x4a,0xfa,0x5e,0x69,0x4a,0x05,0x9e,0x92,0xd3,0xa4,0x3d,0x90,0x0d,0x7f,0x13,0x9b,0x8d,0xd4,0xc0,0xf7};
    std::uint8_t b81_data[32] = {0x7e,0x65,0x1b,0xa5,0xd3,0xe6,0x61,0x59,0x5a,0xec,0xfa,0xbb,0x4a,0xfa,0x5e,0x69,0x4a,0x05,0x9e,0x92,0xd3,0xa4,0x3d,0x90,0x0d,0x7f,0x13,0x9b,0x8d,0xd4,0xc0,0xf7};
    bool         cmp81        = true;
    uint256_from_bytes(a, a81_data);
    uint256_from_bytes(b, b81_data);
    if (uint256_equal(a, b) != cmp81)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a82_data[32] = {0x1b,0xc6,0xb0,0x8b,0x4c,0xe7,0x6f,0x14,0x66,0x02,0xec,0x12,0x0c,0xb9,0x1c,0xbe,0x92,0xf4,0x8d,0x21,0x8b,0x9f,0x68,0x4a,0x67,0xf1,0x86,0xa2,0xe2,0xb6,0xc5,0x0c};
    std::uint8_t b82_data[32] = {0x1b,0xc6,0xb0,0x8b,0x4c,0xe7,0x6f,0x14,0x66,0x02,0xec,0x12,0x0c,0xb9,0x1c,0xbe,0x92,0xf4,0x8d,0x21,0x8b,0x9f,0x68,0x4a,0x67,0xf1,0x86,0xa2,0xe2,0xb6,0xc5,0x0c};
    bool         cmp82        = true;
    uint256_from_bytes(a, a82_data);
    uint256_from_bytes(b, b82_data);
    if (uint256_equal(a, b) != cmp82)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a83_data[32] = {0xc3,0x3e,0xa7,0x3e,0xa0,0x12,0x32,0x46,0x75,0x37,0x94,0x66,0xa2,0x33,0x0a,0x67,0xaa,0xc0,0xa7,0x80,0x0a,0x1a,0xfa,0xea,0x36,0x66,0x7d,0xc9,0x15,0x3f,0xb2,0xcd};
    std::uint8_t b83_data[32] = {0xc3,0x3e,0xa7,0x3e,0xa0,0x12,0x32,0x46,0x75,0x37,0x94,0x66,0xa2,0x33,0x0a,0x67,0xaa,0xc0,0xa7,0x80,0x0a,0x1a,0xfa,0xea,0x36,0x66,0x7d,0xc9,0x15,0x3f,0xb2,0xcd};
    bool         cmp83        = true;
    uint256_from_bytes(a, a83_data);
    uint256_from_bytes(b, b83_data);
    if (uint256_equal(a, b) != cmp83)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a84_data[32] = {0x85,0xab,0xe2,0xed,0x91,0x48,0x29,0xfa,0x7f,0x6d,0x88,0x39,0x0d,0xfb,0x6f,0x3a,0xe9,0xf0,0xef,0x41,0xef,0x11,0x5a,0x1b,0x94,0x0a,0x16,0x24,0xa4,0x4a,0xb3,0xad};
    std::uint8_t b84_data[32] = {0x85,0xab,0xe2,0xed,0x91,0x48,0x29,0xfa,0x7f,0x6d,0x88,0x39,0x0d,0xfb,0x6f,0x3a,0xe9,0xf0,0xef,0x41,0xef,0x11,0x5a,0x1b,0x94,0x0a,0x16,0x24,0xa4,0x4a,0xb3,0xad};
    bool         cmp84        = true;
    uint256_from_bytes(a, a84_data);
    uint256_from_bytes(b, b84_data);
    if (uint256_equal(a, b) != cmp84)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a85_data[32] = {0x01,0x39,0x7a,0x29,0x6d,0x4f,0xdb,0xf8,0x03,0xf9,0xc7,0x3e,0xa0,0x7c,0x30,0xa8,0x26,0xda,0x05,0x3e,0xe5,0x51,0x55,0x0e,0x36,0x57,0xc7,0xbb,0x78,0xe1,0x9b,0xe6};
    std::uint8_t b85_data[32] = {0x3e,0x05,0x6e,0x80,0x91,0xa9,0x4f,0xac,0xb8,0x27,0x63,0xba,0x46,0x83,0x9f,0x5b,0x04,0x8d,0x09,0xc8,0x78,0xea,0xbc,0x3a,0x21,0x04,0x14,0x28,0x1f,0x10,0xa0,0xb3};
    bool         cmp85        = false;
    uint256_from_bytes(a, a85_data);
    uint256_from_bytes(b, b85_data);
    if (uint256_equal(a, b) != cmp85)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a86_data[32] = {0xdb,0x01,0xb9,0xf2,0xb1,0xe1,0x36,0x63,0xb6,0xab,0x58,0xca,0xbf,0x4b,0x3d,0x45,0xc6,0x26,0x60,0x64,0x5d,0xa9,0xe5,0xc9,0x0c,0xd5,0xe3,0xe3,0xec,0x3c,0xd4,0x0d};
    std::uint8_t b86_data[32] = {0xdb,0x01,0xb9,0xf2,0xb1,0xe1,0x36,0x63,0xb6,0xab,0x58,0xca,0xbf,0x4b,0x3d,0x45,0xc6,0x26,0x60,0x64,0x5d,0xa9,0xe5,0xc9,0x0c,0xd5,0xe3,0xe3,0xec,0x3c,0xd4,0x0d};
    bool         cmp86        = true;
    uint256_from_bytes(a, a86_data);
    uint256_from_bytes(b, b86_data);
    if (uint256_equal(a, b) != cmp86)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a87_data[32] = {0x0f,0x4d,0xad,0x88,0x9b,0xe4,0x07,0x8c,0x7c,0x80,0x05,0xc5,0xd5,0xbd,0x01,0x32,0xdc,0x68,0x5e,0x91,0xf5,0x2b,0xc6,0x55,0x2a,0x7e,0xc8,0x06,0x99,0xa1,0x6b,0x9e};
    std::uint8_t b87_data[32] = {0x2a,0x9d,0xcb,0x87,0xad,0x47,0xf8,0xfa,0x78,0x44,0xf2,0x40,0x70,0x50,0x33,0x08,0xba,0x4e,0xe7,0x7a,0x93,0x30,0xca,0x45,0xf2,0xe1,0xee,0xcd,0x5e,0x18,0xc7,0x12};
    bool         cmp87        = false;
    uint256_from_bytes(a, a87_data);
    uint256_from_bytes(b, b87_data);
    if (uint256_equal(a, b) != cmp87)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a88_data[32] = {0x7a,0x1a,0x32,0x93,0x6a,0xff,0xbc,0x9a,0xcd,0x45,0xf3,0x1a,0xa1,0x34,0x75,0xfe,0x29,0xfd,0x96,0xb2,0xa5,0x17,0x6d,0xa0,0xf4,0x32,0x4d,0x92,0x5c,0xfe,0xf9,0x54};
    std::uint8_t b88_data[32] = {0x7a,0x1a,0x32,0x93,0x6a,0xff,0xbc,0x9a,0xcd,0x45,0xf3,0x1a,0xa1,0x34,0x75,0xfe,0x29,0xfd,0x96,0xb2,0xa5,0x17,0x6d,0xa0,0xf4,0x32,0x4d,0x92,0x5c,0xfe,0xf9,0x54};
    bool         cmp88        = true;
    uint256_from_bytes(a, a88_data);
    uint256_from_bytes(b, b88_data);
    if (uint256_equal(a, b) != cmp88)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a89_data[32] = {0x60,0x6d,0xe4,0xeb,0x3f,0x01,0x21,0xf3,0xe3,0x5c,0x18,0xa0,0xf9,0xf4,0x88,0x6c,0x6d,0xb6,0x3a,0xed,0x95,0xac,0xd1,0x4a,0x4f,0x00,0x42,0xf5,0xd5,0x26,0xe8,0xf9};
    std::uint8_t b89_data[32] = {0x73,0x86,0x65,0x61,0xce,0xb7,0x1a,0x8f,0x3b,0xfe,0x93,0x8f,0xe5,0x67,0xda,0xbb,0xc5,0x7d,0x72,0xfe,0x9a,0x0e,0x63,0xe2,0x60,0x4e,0xa2,0xff,0xaf,0x50,0x7d,0xe3};
    bool         cmp89        = false;
    uint256_from_bytes(a, a89_data);
    uint256_from_bytes(b, b89_data);
    if (uint256_equal(a, b) != cmp89)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a90_data[32] = {0xb5,0x55,0xb9,0xfa,0x77,0x1f,0x67,0x2a,0x65,0x3f,0x38,0x7f,0xad,0x7b,0x41,0x76,0x0e,0xbc,0x4b,0xe5,0x9b,0x5d,0xae,0x4e,0x4f,0x39,0x73,0x97,0x3b,0xe9,0x89,0x37};
    std::uint8_t b90_data[32] = {0xb5,0x55,0xb9,0xfa,0x77,0x1f,0x67,0x2a,0x65,0x3f,0x38,0x7f,0xad,0x7b,0x41,0x76,0x0e,0xbc,0x4b,0xe5,0x9b,0x5d,0xae,0x4e,0x4f,0x39,0x73,0x97,0x3b,0xe9,0x89,0x37};
    bool         cmp90        = true;
    uint256_from_bytes(a, a90_data);
    uint256_from_bytes(b, b90_data);
    if (uint256_equal(a, b) != cmp90)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a91_data[32] = {0x07,0xc5,0x97,0xf7,0x98,0xe2,0xe9,0x54,0x50,0xd7,0x94,0x1d,0x27,0xf9,0xc5,0x5d,0x14,0xec,0xe0,0x4c,0xc9,0x8f,0x9b,0xf5,0x76,0xa3,0x99,0xf8,0xa1,0xfb,0x68,0xf1};
    std::uint8_t b91_data[32] = {0x07,0xc5,0x97,0xf7,0x98,0xe2,0xe9,0x54,0x50,0xd7,0x94,0x1d,0x27,0xf9,0xc5,0x5d,0x14,0xec,0xe0,0x4c,0xc9,0x8f,0x9b,0xf5,0x76,0xa3,0x99,0xf8,0xa1,0xfb,0x68,0xf1};
    bool         cmp91        = true;
    uint256_from_bytes(a, a91_data);
    uint256_from_bytes(b, b91_data);
    if (uint256_equal(a, b) != cmp91)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a92_data[32] = {0xb4,0xa0,0x41,0xf3,0xde,0xe4,0x06,0xe8,0x5e,0xa0,0x49,0xa4,0x8e,0xb0,0x78,0xc8,0x08,0xe9,0x50,0x0c,0x0d,0x0e,0x2c,0x33,0x07,0x0b,0x80,0xf4,0x15,0x6a,0x81,0x10};
    std::uint8_t b92_data[32] = {0xb4,0xa0,0x41,0xf3,0xde,0xe4,0x06,0xe8,0x5e,0xa0,0x49,0xa4,0x8e,0xb0,0x78,0xc8,0x08,0xe9,0x50,0x0c,0x0d,0x0e,0x2c,0x33,0x07,0x0b,0x80,0xf4,0x15,0x6a,0x81,0x10};
    bool         cmp92        = true;
    uint256_from_bytes(a, a92_data);
    uint256_from_bytes(b, b92_data);
    if (uint256_equal(a, b) != cmp92)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a93_data[32] = {0x38,0xc2,0xc3,0x9e,0xb8,0x80,0x8c,0x83,0xfd,0xe1,0x15,0x76,0x3c,0x31,0x63,0x62,0xf7,0x3c,0x9a,0x82,0x5e,0xf4,0x07,0x8e,0x28,0xe3,0xf6,0x5a,0xd9,0x85,0x92,0xee};
    std::uint8_t b93_data[32] = {0x97,0x6a,0x45,0xa2,0x96,0xfc,0x31,0xa0,0x4c,0x7d,0xae,0x57,0xbf,0x8b,0x90,0xfa,0xad,0x48,0x9b,0xce,0x32,0xee,0x7f,0x64,0xf0,0x7b,0x3e,0x87,0x01,0x7a,0xa2,0x81};
    bool         cmp93        = false;
    uint256_from_bytes(a, a93_data);
    uint256_from_bytes(b, b93_data);
    if (uint256_equal(a, b) != cmp93)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a94_data[32] = {0x7b,0x37,0x56,0x98,0x5f,0xfe,0xe5,0x5e,0x1f,0xc7,0xdf,0x73,0x63,0xda,0x31,0x77,0x41,0xcb,0x71,0x2f,0x5f,0x26,0xf2,0x1f,0x52,0xec,0x51,0x27,0x78,0x81,0x75,0x48};
    std::uint8_t b94_data[32] = {0x7b,0x37,0x56,0x98,0x5f,0xfe,0xe5,0x5e,0x1f,0xc7,0xdf,0x73,0x63,0xda,0x31,0x77,0x41,0xcb,0x71,0x2f,0x5f,0x26,0xf2,0x1f,0x52,0xec,0x51,0x27,0x78,0x81,0x75,0x48};
    bool         cmp94        = true;
    uint256_from_bytes(a, a94_data);
    uint256_from_bytes(b, b94_data);
    if (uint256_equal(a, b) != cmp94)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a95_data[32] = {0xd5,0x34,0xc0,0x87,0xed,0x7c,0x5d,0xa0,0x28,0x2e,0x47,0x8c,0x09,0x38,0x1e,0xfa,0xcc,0x81,0x63,0x56,0x31,0xf2,0x51,0xc2,0xe9,0x9f,0x4a,0x92,0xb7,0x9c,0x2b,0x63};
    std::uint8_t b95_data[32] = {0xd5,0x34,0xc0,0x87,0xed,0x7c,0x5d,0xa0,0x28,0x2e,0x47,0x8c,0x09,0x38,0x1e,0xfa,0xcc,0x81,0x63,0x56,0x31,0xf2,0x51,0xc2,0xe9,0x9f,0x4a,0x92,0xb7,0x9c,0x2b,0x63};
    bool         cmp95        = true;
    uint256_from_bytes(a, a95_data);
    uint256_from_bytes(b, b95_data);
    if (uint256_equal(a, b) != cmp95)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a96_data[32] = {0x69,0x6a,0x86,0x17,0x6b,0x13,0x49,0x07,0x44,0x32,0x94,0x63,0x26,0x3e,0x8d,0xb3,0xde,0xe7,0xb6,0x44,0x70,0x60,0x67,0xab,0x25,0x0b,0xc6,0xe7,0xe3,0xaa,0x47,0x1c};
    std::uint8_t b96_data[32] = {0x69,0x6a,0x86,0x17,0x6b,0x13,0x49,0x07,0x44,0x32,0x94,0x63,0x26,0x3e,0x8d,0xb3,0xde,0xe7,0xb6,0x44,0x70,0x60,0x67,0xab,0x25,0x0b,0xc6,0xe7,0xe3,0xaa,0x47,0x1c};
    bool         cmp96        = true;
    uint256_from_bytes(a, a96_data);
    uint256_from_bytes(b, b96_data);
    if (uint256_equal(a, b) != cmp96)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a97_data[32] = {0xf8,0x7f,0xcf,0x8e,0x33,0x9d,0x7c,0xf8,0xc1,0x3d,0xe7,0xcf,0x41,0xfe,0xbb,0x34,0x1e,0x83,0x2d,0x72,0x49,0x46,0x93,0x68,0xd5,0xd5,0x0f,0x76,0x7a,0x3a,0x83,0x94};
    std::uint8_t b97_data[32] = {0xf8,0x7f,0xcf,0x8e,0x33,0x9d,0x7c,0xf8,0xc1,0x3d,0xe7,0xcf,0x41,0xfe,0xbb,0x34,0x1e,0x83,0x2d,0x72,0x49,0x46,0x93,0x68,0xd5,0xd5,0x0f,0x76,0x7a,0x3a,0x83,0x94};
    bool         cmp97        = true;
    uint256_from_bytes(a, a97_data);
    uint256_from_bytes(b, b97_data);
    if (uint256_equal(a, b) != cmp97)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a98_data[32] = {0x4b,0x24,0x6a,0xa0,0xfa,0x81,0x1b,0x6d,0xb9,0xfa,0x20,0xfb,0xd5,0x13,0x21,0xff,0x0e,0xb7,0x2a,0x15,0x29,0x85,0x86,0x91,0xe5,0x6d,0x54,0x04,0x6a,0x67,0x1e,0xcc};
    std::uint8_t b98_data[32] = {0x4b,0x24,0x6a,0xa0,0xfa,0x81,0x1b,0x6d,0xb9,0xfa,0x20,0xfb,0xd5,0x13,0x21,0xff,0x0e,0xb7,0x2a,0x15,0x29,0x85,0x86,0x91,0xe5,0x6d,0x54,0x04,0x6a,0x67,0x1e,0xcc};
    bool         cmp98        = true;
    uint256_from_bytes(a, a98_data);
    uint256_from_bytes(b, b98_data);
    if (uint256_equal(a, b) != cmp98)
    {
        throw std::runtime_error("err in uint256_equal");
    }
    std::uint8_t a99_data[32] = {0x5c,0x2f,0x76,0x26,0x2f,0x91,0xf0,0xc5,0x49,0x51,0x25,0xcc,0x86,0xce,0x62,0x5e,0xf1,0x92,0xcc,0xb5,0xd5,0x0d,0xfd,0xea,0xca,0x20,0xed,0x96,0x00,0x7e,0x07,0x12};
    std::uint8_t b99_data[32] = {0x99,0xc4,0x53,0xef,0x32,0x5b,0xaf,0x8e,0x2c,0xf5,0xec,0x78,0xb6,0x2c,0x9d,0xcb,0x3a,0xfc,0xd2,0xae,0xc5,0x3b,0xee,0xbd,0x85,0x8b,0x08,0x9a,0x2e,0x1c,0xfd,0xd8};
    bool         cmp99        = false;
    uint256_from_bytes(a, a99_data);
    uint256_from_bytes(b, b99_data);
    if (uint256_equal(a, b) != cmp99)
    {
        throw std::runtime_error("err in uint256_equal");
    }
}
